#!/usr/bin/python3 -u
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

"""
abrt-action-find-bodhi-update - find bodhi update based on ABRT's problem dir

The tool reads duphash file in problem directory and searches for a new updates
according to the crash.

OPTIONS
    -v, --verbose
        Be verbose

    -b, --without-bodhi
        Run without abrt-bodhi. Prints only Bugzilla bug id of duplicate bug,
        if exists.

    -d, --problem-dir PROBLEM_DIR
        Problem directory [Default: current directory]

ENVIRONMENT VARIABLES
    Bugzilla_Product
        Product bug field value. Useful if you needed different product than
        specified in PROBLEM_DIR/os_info
"""
import os
import sys
from argparse import ArgumentParser
from subprocess import Popen, PIPE

from reportclient import (_, log_warning, log1, set_verbosity, verbose, RETURN_OK,
                          RETURN_FAILURE, error_msg)
import report

FILENAME_DUPHASH = "duphash"
FILENAME_OSINFO = "os_info"
OSINFO_BUGZILLA_PRODUCT = "REDHAT_BUGZILLA_PRODUCT="
OSINFO_BUGZILLA_PRODUCT_VERSION = "REDHAT_BUGZILLA_PRODUCT_VERSION="

def parse_os_release_line(l):
    """Parse key-value line and returns value"""
    return l.split('=')[1]

if __name__ == "__main__":
    CMDARGS = ArgumentParser(
            description=("Search bodhi updates based on ABRT's problem dir"))
    CMDARGS.add_argument("-d", "--problem-dir",
            type=str, default=".",
            help="Path to problem directory")
    CMDARGS.add_argument("-b", "--without-bodhi",
            action="store_true", dest="without_bodhi", default=False,
            help="Run without abrt-bohi")
    CMDARGS.add_argument("-v", "--verbose",
            action="count", dest="verbose", default=0,
            help="Be verbose")

    OPTIONS = CMDARGS.parse_args()
    try:
        DIR_PATH = os.path.abspath(OPTIONS.problem_dir)
    except FileNotFoundError as ex:
        error_msg(_("Problem directory error: {0}").format(ex))
        sys.exit(RETURN_FAILURE)

    verbose = 0
    ABRT_VERBOSE = os.getenv("ABRT_VERBOSE")
    if ABRT_VERBOSE:
        try:
            verbose = int(ABRT_VERBOSE)
        #pylint: disable=bare-except
        except:
            pass

    verbose += OPTIONS.verbose
    set_verbosity(verbose)
    os.environ["ABRT_VERBOSE"] = str(verbose)

    try:
        dump_dir = report.dd_opendir(DIR_PATH, report.DD_OPEN_READONLY)
        if not dump_dir:
            raise ValueError(_("cannot open problem directory '{0}'").format(DIR_PATH))

        dd_load_flag = (report.DD_LOAD_TEXT_RETURN_NULL_ON_FAILURE |
                        report.DD_FAIL_QUIETLY_ENOENT)

        duphash_content = dump_dir.load_text(FILENAME_DUPHASH, dd_load_flag)
        if not duphash_content:
            raise ValueError("problem directory misses '{0}'".format(FILENAME_DUPHASH))

        os_info = dump_dir.load_text(FILENAME_OSINFO, dd_load_flag)
        if not os_info:
            raise ValueError("problem directory misses '{0}'" .format(FILENAME_OSINFO))

    except ValueError as ex:
        error_msg(_("Problem directory error: {0}").format(ex))
        sys.exit(RETURN_FAILURE)
    finally:
        dump_dir.close()

    # get Bugzilla Product and Version from os_info
    product = os.getenv("Bugzilla_Product") or ""
    version = ""
    for line in os_info.split("\n"):
        if (OSINFO_BUGZILLA_PRODUCT in line) and (product == ""):
            product = parse_os_release_line(line)
        if OSINFO_BUGZILLA_PRODUCT_VERSION in line:
            version = parse_os_release_line(line)

    if product == "":
        log1(_("Using product '{0}' from /etc/os-release.").format(OSINFO_BUGZILLA_PRODUCT))
    else:
        log1(_("Using product {0}.").format(product))
    if version != "":
        log1(_("Using product version {0}.").format(version))

    # Find bugzilla bug with abrt_hash: == $duphash_content and product ==
    # $product, if OSINFO_BUGZILLA_PRODUCT from crash's os_info doesn't exist,
    # the OSINFO_BUGZILLA_PRODUCT from /etc/os-release is used
    with Popen(["reporter-bugzilla -h {0} -p{1}".format(duphash_content, product)],
             shell=True,
             stdout=PIPE,
             bufsize=-1) as proc:
        bug_id = proc.stdout.read().rstrip().decode("utf-8", "ignore")

    if bug_id:
        log_warning(_("Duplicate bugzilla bug '#{0}' was found").format(bug_id))
    else:
        log1(_("There is no bugzilla bug with 'abrt_hash:{0}'").format(duphash_content))
        sys.exit(RETURN_OK)

    # abrt-bodhi do not support rawhide, because there are no updates for rawhide in Bodhi
    if "rawhide" in version.lower():
        log1(_("Warning: abrt-bodhi do not support Product version 'Rawhide'"))
        sys.exit(RETURN_OK)

    if not OPTIONS.without_bodhi:
        Popen(["abrt-bodhi -r -b {0} -d {1}".format(bug_id, DIR_PATH)],
                shell=True,
                bufsize=-1).wait()

    sys.exit(RETURN_OK)
